Concurrent computing environments use ever more powerful and complex multicore and/or multi-CPU platforms, with highly multithreaded operations. Especially where multiple and simultaneous producers (e.g., writers) and consumers (e.g., readers) operate on a given memory structure, this heightens the risk of process and/or thread contention, latency, and inefficient memory usage. As a result, concurrent computing can be associated with significant performance constraints. Such constraints can slow current processes and impose an opportunity cost of foregone added ones.
Mechanisms have been designed to address these constraints. These include locking mechanisms that can selectively brake producers so that consumers can “catch up.” Disadvantages of locking mechanisms are known and can include significant wait times, thread stalls or thread death, and limited scalability. A lock-free mechanism, however, presents challenges as well, including the A-B-A problem, where state can appear identical from a first read to a second read, but in fact a separate process has “secretly” modified shared memory before changing it back again.